home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 1.0 beta / flock-1.0RC3.en-US.win32.exe / flock / components / FeedConverter.js < prev    next >
Text File  |  2007-10-18  |  21KB  |  624 lines
  1. //@line 38 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/FeedConverter.js"
  2.  
  3. const Cc = Components.classes;
  4. const Ci = Components.interfaces;
  5. const Cr = Components.results;
  6.  
  7. function LOG(str) {
  8.   dump("*** " + str + "\n");
  9. }
  10.  
  11. const FC_CLASSID = Components.ID("{229fa115-9412-4d32-baf3-2fc407f76fb1}");
  12. const FC_CLASSNAME = "Feed Stream Converter";
  13. const FS_CLASSID = Components.ID("{2376201c-bbc6-472f-9b62-7548040a61c6}");
  14. const FS_CLASSNAME = "Feed Result Service";
  15. const FS_CONTRACTID = "@mozilla.org/browser/feeds/result-service;1";
  16. const FPH_CONTRACTID = "@mozilla.org/network/protocol;1?name=feed";
  17. const FPH_CLASSID = Components.ID("{4f91ef2e-57ba-472e-ab7a-b4999e42d6c0}");
  18. const FPH_CLASSNAME = "Feed Protocol Handler";
  19. const PCPH_CONTRACTID = "@mozilla.org/network/protocol;1?name=pcast";
  20. const PCPH_CLASSID = Components.ID("{1c31ed79-accd-4b94-b517-06e0c81999d5}");
  21. const PCPH_CLASSNAME = "Podcast Protocol Handler";
  22. const FHS_CONTRACTID = "@mozilla.org/browser/feeds/handler-service;1";
  23. const FHS_CLASSID = Components.ID("{792a7e82-06a0-437c-af63-b2d12e808acc}");
  24. const FHS_CLASSNAME = "Feed Handler Service";
  25.  
  26. const TYPE_MAYBE_FEED = "application/vnd.mozilla.maybe.feed";
  27. const TYPE_ANY = "*/*";
  28.  
  29. //const FEEDHANDLER_URI = "about:feeds";
  30. const FEEDHANDLER_URI = "flock://preview/";
  31.  
  32. const PREF_SELECTED_APP = "browser.feeds.handlers.application";
  33. const PREF_SELECTED_WEB = "browser.feeds.handlers.webservice";
  34. const PREF_SELECTED_ACTION = "browser.feeds.handler";
  35. const PREF_SELECTED_READER = "browser.feeds.handler.default";
  36.  
  37. function safeGetBoolPref(pref, defaultValue) {
  38.   var prefs =   
  39.       Cc["@mozilla.org/preferences-service;1"].
  40.       getService(Ci.nsIPrefBranch);
  41.   try {
  42.     return prefs.getBoolPref(pref);
  43.   }
  44.   catch (e) {
  45.   }
  46.   return defaultValue;
  47. }
  48.  
  49. function safeGetCharPref(pref, defaultValue) {
  50.   var prefs =   
  51.       Cc["@mozilla.org/preferences-service;1"].
  52.       getService(Ci.nsIPrefBranch);
  53.   try {
  54.     return prefs.getCharPref(pref);
  55.   }
  56.   catch (e) {
  57.   }
  58.   return defaultValue;
  59. }
  60.  
  61. function FeedConverter() {
  62. }
  63. FeedConverter.prototype = {
  64.   /**
  65.    * This is the downloaded text data for the feed.
  66.    */
  67.   _data: null,
  68.   
  69.   /**
  70.    * This is the object listening to the conversion, which is ultimately the
  71.    * docshell for the load.
  72.    */
  73.   _listener: null,
  74.  
  75.   /**
  76.    * Records if the feed was sniffed
  77.    */
  78.   _sniffed: false,
  79.   
  80.   /**
  81.    * See nsIStreamConverter.idl
  82.    */
  83.   canConvert: function FC_canConvert(sourceType, destinationType) {
  84.     // We only support one conversion.
  85.     return destinationType == TYPE_ANY && sourceType == TYPE_MAYBE_FEED;
  86.   },
  87.   
  88.   /**
  89.    * See nsIStreamConverter.idl
  90.    */
  91.   convert: function FC_convert(sourceStream, sourceType, destinationType, 
  92.                                context) {
  93.     throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  94.   },
  95.   
  96.   /**
  97.    * See nsIStreamConverter.idl
  98.    */
  99.   asyncConvertData: function FC_asyncConvertData(sourceType, destinationType,
  100.                                                  listener, context) {
  101.     this._listener = listener;
  102.   },
  103.   
  104.   /**
  105.    * Whether or not the preview page is being forced.
  106.    */
  107.   _forcePreviewPage: false,
  108.  
  109.   /** 
  110.    * Release our references to various things once we're done using them.
  111.    */
  112.   _releaseHandles: function FC__releaseHandles() {
  113.     this._listener = null;
  114.     this._request = null;
  115.   },
  116.  
  117.   /**
  118.    * See nsIFeedResultListener.idl
  119.    */
  120.   handleResult: function FC_handleResult(result) {
  121.     // Feeds come in various content types, which our feed sniffer coerces to
  122.     // the maybe.feed type. However, feeds are used as a transport for 
  123.     // different data types, e.g. news/blogs (traditional feed), video/audio
  124.     // (podcasts) and photos (photocasts, photostreams). Each of these is 
  125.     // different in that there's a different class of application suitable for
  126.     // handling feeds of that type, but without a content-type differentiation
  127.     // it is difficult for us to disambiguate.
  128.     // 
  129.     // The other problem is that if the user specifies an auto-action handler
  130.     // for one feed application, the fact that the content type is shared means 
  131.     // that all other applications will auto-load with that handler too, 
  132.     // regardless of the content-type. 
  133.     //
  134.     // This means that content-type alone is not enough to determine whether
  135.     // or not a feed should be auto-handled. This means that for feeds we need
  136.     // to always use this stream converter, even when an auto-action is 
  137.     // specified, not the basic one provided by WebContentConverter. This 
  138.     // converter needs to consume all of the data and parse it, and based on
  139.     // that determination make a judgement about type. 
  140.     //
  141.     // Since there are no content types for this content, and I'm not going to
  142.     // invent any, the upshot is that while a user can set an auto-handler for
  143.     // generic feed content, the system will prevent them from setting an auto-
  144.     // handler for other stream types. In those cases, the user will always see
  145.     // the preview page and have to select a handler. We can guess and show 
  146.     // a client handler, but will not be able to show web handlers for those
  147.     // types.
  148.     //
  149.     // If this is just a feed, not some kind of specialized application, then
  150.     // auto-handlers can be set and we should obey them. 
  151.     try {
  152.       var feedService = 
  153.           Cc["@mozilla.org/browser/feeds/result-service;1"].
  154.           getService(Ci.nsIFeedResultService);
  155.       if (!this._forcePreviewPage && result.doc) {
  156.         var handler = safeGetCharPref(PREF_SELECTED_ACTION, "ask");
  157.         if (handler != "ask") {
  158.           if (handler == "reader")
  159.             handler = safeGetCharPref(PREF_SELECTED_READER, "bookmarks");
  160.           switch (handler) {
  161.             case "web":
  162.               var wccr = 
  163.                   Cc["@mozilla.org/embeddor.implemented/web-content-handler-registrar;1"].
  164.                   getService(Ci.nsIWebContentConverterService);
  165.               var feed = result.doc.QueryInterface(Ci.nsIFeed);
  166.               if (feed.type == Ci.nsIFeed.TYPE_FEED &&
  167.                   wccr.getAutoHandler(TYPE_MAYBE_FEED)) {
  168.                 wccr.loadPreferredHandler(this._request);
  169.                 return;
  170.               }
  171.               break;
  172.  
  173.             default:
  174.               LOG("unexpected handler: " + handler);
  175.               // fall through -- let feed service handle error
  176.             case "bookmarks":
  177.             case "client":
  178.               try {
  179.                 var feed = result.doc.QueryInterface(Ci.nsIFeed);
  180.                 var title = feed.title ? feed.title.plainText() : "";
  181.                 var desc = feed.subtitle ? feed.subtitle.plainText() : "";
  182.                 feedService.addToClientReader(result.uri.spec, title, desc);
  183.                 return;
  184.               }
  185.               catch(ex) { /* fallback to preview mode */ }
  186.           }
  187.         }
  188.       }
  189.  
  190.       var ios = 
  191.            Cc["@mozilla.org/network/io-service;1"].
  192.            getService(Ci.nsIIOService);
  193.       var chromeChannel;
  194.  
  195.       // show the feed page if it wasn't sniffed and we have a document,
  196.       // or we have a document, title, and link or id
  197.       if (result.doc && (!this._sniffed ||
  198.           (result.doc.title && (result.doc.link || result.doc.id)))) {
  199.         // If there was no automatic handler, or this was a podcast,
  200.         // photostream or some other kind of application, we must always
  201.         // show the preview page...
  202.  
  203.         // Store the result in the result service so that the display page can 
  204.         // access it.
  205.         //feedService.addFeedResult(result);
  206.         
  207.         var feedManager =
  208.             Cc["@flock.com/feed-manager;1"].
  209.             getService(Ci.flockIFeedManager);
  210.         var originalURI = this._request.originalURI;
  211.         if (feedManager.getFeedContext("news").existsSubscription(originalURI)) {
  212.           var encoded = encodeURIComponent("urn:flock:feed:" + originalURI.spec);
  213.           var chromeURI = ios.newURI("flock://favorites/" + encoded, null, null);
  214.           chromeChannel = ios.newChannelFromURI(chromeURI, null);
  215.           chromeChannel.originalURI = chromeURI;
  216.         } else {
  217.           feedManager.storeFeed(originalURI, result);
  218.           var encoded = encodeURIComponent(originalURI.spec);
  219.           var chromeURI = ios.newURI("flock://preview/" + encoded, null, null);
  220.           chromeChannel = ios.newChannelFromURI(chromeURI, null);
  221.           chromeChannel.originalURI = originalURI;
  222.         }
  223.       }
  224.       else
  225.         chromeChannel = ios.newChannelFromURI(result.uri, null);
  226.  
  227.       chromeChannel.loadGroup = this._request.loadGroup;
  228.       chromeChannel.asyncOpen(this._listener, null);
  229.     }
  230.     finally {
  231.       this._releaseHandles();
  232.     }
  233.   },
  234.   
  235.   /**
  236.    * See nsIStreamListener.idl
  237.    */
  238.   onDataAvailable: function FC_onDataAvailable(request, context, inputStream, 
  239.                                                sourceOffset, count) {
  240.     this._processor.onDataAvailable(request, context, inputStream,
  241.                                     sourceOffset, count);
  242.   },
  243.   
  244.   /**
  245.    * See nsIRequestObserver.idl
  246.    */
  247.   onStartRequest: function FC_onStartRequest(request, context) {
  248.     var channel = request.QueryInterface(Ci.nsIChannel);
  249.  
  250.     // Check for a header that tells us there was no sniffing
  251.     // The value doesn't matter.
  252.     try {
  253.       var httpChannel = channel.QueryInterface(Ci.nsIHttpChannel);
  254.       var noSniff = httpChannel.getResponseHeader("X-Moz-Is-Feed");
  255.     }
  256.     catch (ex) {
  257.       this._sniffed = true;
  258.     }
  259.  
  260.     this._request = request;
  261.     
  262.     // Save and reset the forced state bit early, in case there's some kind of
  263.     // error.
  264.     var feedService = 
  265.         Cc["@mozilla.org/browser/feeds/result-service;1"].
  266.         getService(Ci.nsIFeedResultService);
  267.     this._forcePreviewPage = feedService.forcePreviewPage;
  268.     feedService.forcePreviewPage = false;
  269.  
  270.     // Parse feed data as it comes in
  271.     this._processor =
  272.         Cc["@mozilla.org/feed-processor;1"].
  273.         createInstance(Ci.nsIFeedProcessor);
  274.     this._processor.listener = this;
  275.     this._processor.parseAsync(null, channel.URI);
  276.     
  277.     this._processor.onStartRequest(request, context);
  278.   },
  279.   
  280.   /**
  281.    * See nsIRequestObserver.idl
  282.    */
  283.   onStopRequest: function FC_onStopRequest(request, context, status) {
  284.     this._processor.onStopRequest(request, context, status);
  285.   },
  286.   
  287.   /**
  288.    * See nsISupports.idl
  289.    */
  290.   QueryInterface: function FC_QueryInterface(iid) {
  291.     if (iid.equals(Ci.nsIFeedResultListener) ||
  292.         iid.equals(Ci.nsIStreamConverter) ||
  293.         iid.equals(Ci.nsIStreamListener) ||
  294.         iid.equals(Ci.nsIRequestObserver)||
  295.         iid.equals(Ci.nsISupports))
  296.       return this;
  297.     throw Cr.NS_ERROR_NO_INTERFACE;
  298.   },
  299. };
  300.  
  301. var FeedConverterFactory = {
  302.   createInstance: function FS_createInstance(outer, iid) {
  303.     if (outer != null)
  304.       throw Cr.NS_ERROR_NO_AGGREGATION;
  305.     return new FeedConverter().QueryInterface(iid);
  306.   },
  307.  
  308.   QueryInterface: function FS_QueryInterface(iid) {
  309.     if (iid.equals(Ci.nsIFactory) ||
  310.         iid.equals(Ci.nsISupports))
  311.       return this;
  312.     throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  313.   },
  314. };
  315.  
  316. /**
  317.  * Keeps parsed FeedResults around for use elsewhere in the UI after the stream
  318.  * converter completes. 
  319.  */
  320. var FeedResultService = {
  321.   
  322.   /**
  323.    * A URI spec -> [nsIFeedResult] hash. We have to keep a list as the
  324.    * value in case the same URI is requested concurrently.
  325.    */
  326.   _results: { },
  327.   
  328.   /**
  329.    * See nsIFeedService.idl
  330.    */
  331.   forcePreviewPage: false,
  332.   
  333.   /**
  334.    * See nsIFeedService.idl
  335.    */
  336.   addToClientReader: function FRS_addToClientReader(spec, title, subtitle) {
  337.     var prefs =   
  338.         Cc["@mozilla.org/preferences-service;1"].
  339.         getService(Ci.nsIPrefBranch);
  340.  
  341.     var handler = safeGetCharPref(PREF_SELECTED_ACTION, "bookmarks");
  342.     if (handler == "ask" || handler == "reader")                                
  343.       handler = safeGetCharPref(PREF_SELECTED_READER, "bookmarks");             
  344.  
  345.     switch (handler) {
  346.     case "client":
  347.       var clientApp = 
  348.         prefs.getComplexValue(PREF_SELECTED_APP, Ci.nsILocalFile);
  349. //@line 406 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/FeedConverter.js"
  350.       var ss = 
  351.           Cc["@mozilla.org/browser/shell-service;1"].
  352.           getService(Ci.nsIShellService_MOZILLA_1_8_BRANCH);
  353.       ss.openApplicationWithURI(clientApp, spec);
  354.       break;
  355.  
  356.     default:
  357.       // "web" should have been handled elsewhere
  358.       LOG("unexpected handler: " + handler);
  359.       // fall through
  360.     case "bookmarks":
  361.       var wm = 
  362.           Cc["@mozilla.org/appshell/window-mediator;1"].
  363.           getService(Ci.nsIWindowMediator);
  364.       var topWindow = wm.getMostRecentWindow("navigator:browser");
  365. //@line 424 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/FeedConverter.js"
  366.       topWindow.FeedHandler.addLiveBookmark(spec, title, subtitle);
  367. //@line 426 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/FeedConverter.js"
  368.       break;
  369.     }
  370.   },
  371.   
  372.   /**
  373.    * See nsIFeedService.idl
  374.    */
  375.   addFeedResult: function FRS_addFeedResult(feedResult) {
  376.     NS_ASSERT(feedResult.uri != null, "null URI!");
  377.     NS_ASSERT(feedResult.uri != null, "null feedResult!");
  378.     var spec = feedResult.uri.spec;
  379.     if(!this._results[spec])  
  380.       this._results[spec] = [];
  381.     this._results[spec].push(feedResult);
  382.   },
  383.   
  384.   /**
  385.    * See nsIFeedService.idl
  386.    */
  387.   getFeedResult: function RFS_getFeedResult(uri) {
  388.     NS_ASSERT(uri != null, "null URI!");
  389.     var resultList = this._results[uri.spec];
  390.     for (var i in resultList) {
  391.       if (resultList[i].uri == uri)
  392.         return resultList[i];
  393.     }
  394.     return null;
  395.   },
  396.   
  397.   /**
  398.    * See nsIFeedService.idl
  399.    */
  400.   removeFeedResult: function FRS_removeFeedResult(uri) {
  401.     NS_ASSERT(uri != null, "null URI!");
  402.     var resultList = this._results[uri.spec];
  403.     if (!resultList)
  404.       return;
  405.     var deletions = 0;
  406.     for (var i = 0; i < resultList.length; ++i) {
  407.       if (resultList[i].uri == uri) {
  408.         delete resultList[i];
  409.         ++deletions;
  410.       }
  411.     }
  412.     
  413.     // send the holes to the end
  414.     resultList.sort();
  415.     // and trim the list
  416.     resultList.splice(resultList.length - deletions, deletions);
  417.     if (resultList.length == 0)
  418.       delete this._results[uri.spec];
  419.   },
  420.  
  421.   createInstance: function FRS_createInstance(outer, iid) {
  422.     if (outer != null)
  423.       throw Cr.NS_ERROR_NO_AGGREGATION;
  424.     return this.QueryInterface(iid);
  425.   },
  426.   
  427.   QueryInterface: function FRS_QueryInterface(iid) {
  428.     if (iid.equals(Ci.nsIFeedResultService) ||
  429.         iid.equals(Ci.nsIFactory) ||
  430.         iid.equals(Ci.nsISupports))
  431.       return this;
  432.     throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  433.   },
  434. };
  435.  
  436. /**
  437.  * A protocol handler that converts the URIs of Apple's various bogo protocol
  438.  * schemes into http, as they should be. Mostly, this object just forwards 
  439.  * things through to the HTTP protocol handler.
  440.  */
  441. function FeedProtocolHandler(scheme) {
  442.   this._scheme = scheme;
  443.   var ios = 
  444.       Cc["@mozilla.org/network/io-service;1"].
  445.       getService(Ci.nsIIOService);
  446.   this._http = ios.getProtocolHandler("http");
  447. }
  448. FeedProtocolHandler.prototype = {
  449.   _scheme: "",
  450.   get scheme() {
  451.     return this._scheme;
  452.   },
  453.   
  454.   get protocolFlags() {
  455.     return this._http.protocolFlags;
  456.   },
  457.   
  458.   get defaultPort() {
  459.     return this._http.defaultPort;
  460.   },
  461.   
  462.   allowPort: function FPH_allowPort(port, scheme) {
  463.     return this._http.allowPort(port, scheme);
  464.   },
  465.   
  466.   newURI: function FPH_newURI(spec, originalCharset, baseURI) {
  467.     var uri = 
  468.         Cc["@mozilla.org/network/standard-url;1"].
  469.         createInstance(Ci.nsIStandardURL);
  470.     uri.init(Ci.nsIStandardURL.URLTYPE_STANDARD, 80, spec, originalCharset,
  471.              baseURI);
  472.     return uri;
  473.   },
  474.   
  475.   newChannel: function FPH_newChannel(uri) {
  476.     var ios = 
  477.         Cc["@mozilla.org/network/io-service;1"].
  478.         getService(Ci.nsIIOService);
  479.     // feed: URIs either start feed://, in which case the real scheme is http:
  480.     // or feed:http(s)://, (which by now we've changed to feed://realscheme//)
  481.     const httpsChunk = "feed://https//";
  482.     const httpChunk = "feed://http//";
  483.     if (uri.spec.substr(0, httpsChunk.length) == httpsChunk)
  484.       uri.spec = "https://" + uri.spec.substr(httpsChunk.length);
  485.     else if (uri.spec.substr(0, httpChunk.length) == httpChunk)
  486.       uri.spec = "http://" + uri.spec.substr(httpChunk.length);
  487.     else
  488.       uri.scheme = "http";
  489.  
  490.     var channel =
  491.       ios.newChannelFromURI(uri, null).QueryInterface(Ci.nsIHttpChannel);
  492.     // Set this so we know this is supposed to be a feed
  493.     channel.setRequestHeader("X-Moz-Is-Feed", "1", false);
  494.     channel.originalURI = uri;
  495.     return channel;
  496.   },
  497.   
  498.   QueryInterface: function FPH_QueryInterface(iid) {
  499.     if (iid.equals(Ci.nsIProtocolHandler) ||
  500.         iid.equals(Ci.nsISupports))
  501.       return this;
  502.     throw Cr.NS_ERROR_NO_INTERFACE;
  503.   }  
  504. };
  505.  
  506. var Module = {
  507.   QueryInterface: function M_QueryInterface(iid) {
  508.     if (iid.equals(Ci.nsIModule) ||
  509.         iid.equals(Ci.nsISupports))
  510.       return this;
  511.     throw Cr.NS_ERROR_NO_INTERFACE;
  512.   },
  513.   
  514.   getClassObject: function M_getClassObject(cm, cid, iid) {
  515.     if (!iid.equals(Ci.nsIFactory))
  516.       throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  517.     
  518.     if (cid.equals(FS_CLASSID))
  519.       return FeedResultService;
  520.     if (cid.equals(FPH_CLASSID))
  521.       return new GenericComponentFactory(FeedProtocolHandler, "feed");
  522.     if (cid.equals(PCPH_CLASSID))
  523.       return new GenericComponentFactory(FeedProtocolHandler, "pcast");
  524.     if (cid.equals(FC_CLASSID))
  525.       return new GenericComponentFactory(FeedConverter);
  526.       
  527.     throw Cr.NS_ERROR_NO_INTERFACE;
  528.   },
  529.   
  530.   registerSelf: function M_registerSelf(cm, file, location, type) {
  531.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  532.     
  533.     cr.registerFactoryLocation(FS_CLASSID, FS_CLASSNAME, FS_CONTRACTID,
  534.                                file, location, type);
  535.     cr.registerFactoryLocation(FPH_CLASSID, FPH_CLASSNAME, FPH_CONTRACTID,
  536.                                file, location, type);
  537.     cr.registerFactoryLocation(PCPH_CLASSID, PCPH_CLASSNAME, PCPH_CONTRACTID,
  538.                                file, location, type);
  539.  
  540.     // The feed converter is always attached, since parsing must be done to 
  541.     // determine whether or not auto-handling can occur. 
  542.     const converterPrefix = "@mozilla.org/streamconv;1?from=";
  543.     var converterContractID = 
  544.         converterPrefix + TYPE_MAYBE_FEED + "&to=" + TYPE_ANY;
  545.     cr.registerFactoryLocation(FC_CLASSID, FC_CLASSNAME, converterContractID,
  546.                                file, location, type);
  547.   },
  548.   
  549.   unregisterSelf: function M_unregisterSelf(cm, location, type) {
  550.     var cr = cm.QueryInterface(Ci.nsIComponentRegistrar);
  551.     cr.unregisterFactoryLocation(FPH_CLASSID, location);
  552.     cr.unregisterFactoryLocation(PCPH_CLASSID, location);
  553.   },
  554.   
  555.   canUnload: function M_canUnload(cm) {
  556.     return true;
  557.   }
  558. };
  559.  
  560. function NSGetModule(cm, file) {
  561.   return Module;
  562. }
  563.  
  564. //@line 44 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/../../../../toolkit/content/debug.js"
  565.  
  566. var gTraceOnAssert = true;
  567.  
  568. /**
  569.  * This function provides a simple assertion function for JavaScript.
  570.  * If the condition is true, this function will do nothing.  If the
  571.  * condition is false, then the message will be printed to the console
  572.  * and an alert will appear showing a stack trace, so that the (alpha
  573.  * or nightly) user can file a bug containing it.  For future enhancements, 
  574.  * see bugs 330077 and 330078.
  575.  *
  576.  * To suppress the dialogs, you can run with the environment variable
  577.  * XUL_ASSERT_PROMPT set to 0 (if unset, this defaults to 1).
  578.  *
  579.  * @param condition represents the condition that we're asserting to be
  580.  *                  true when we call this function--should be
  581.  *                  something that can be evaluated as a boolean.
  582.  * @param message   a string to be displayed upon failure of the assertion
  583.  */
  584.  
  585. function NS_ASSERT(condition, message) {
  586.   if (condition)
  587.     return;
  588.  
  589.   var assertionText = "ASSERT: " + message + "\n";
  590.  
  591. //@line 72 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/../../../../toolkit/content/debug.js"
  592.   Components.util.reportError(assertionText);
  593.   return;
  594. //@line 108 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/../../../../toolkit/content/debug.js"
  595. }
  596. //@line 37 "/cygdrive/K/tinderbuild/src/flock/mozilla/browser/components/feeds/src/GenericFactory.js"
  597.  
  598. /**
  599.  * An object implementing nsIFactory that can construct other objects upon
  600.  * createInstance, passing a set of parameters to that object's constructor.
  601.  */
  602. function GenericComponentFactory(ctor, params) {
  603.   this._ctor = ctor;
  604.   this._params = params;
  605. }
  606. GenericComponentFactory.prototype = {
  607.   _ctor: null,
  608.   _params: null,
  609.   
  610.   createInstance: function GCF_createInstance(outer, iid) {
  611.     if (outer != null)
  612.       throw Cr.NS_ERROR_NO_AGGREGATION;
  613.     return (new this._ctor(this._params)).QueryInterface(iid);
  614.   },
  615.   
  616.   QueryInterface: function GCF_QueryInterface(iid) {
  617.     if (iid.equals(Ci.nsIFactory) ||
  618.         iid.equals(Ci.nsISupports)) 
  619.       return this;
  620.     throw Cr.NS_ERROR_NO_INTERFACE;
  621.   }
  622. };
  623.  
  624.